///*// * Copyright 2021 Shulie Technology, Co.Ltd// * Email: shulie@shulie.io// * Licensed under the Apache License, Version 2.0 (the "License");// * you may not use this file except in compliance with the License.// * You may obtain a copy of the License at// *// *      http://www.apache.org/licenses/LICENSE-2.0// *// * Unless required by applicable law or agreed to in writing, software// * distributed under the License is distributed on an "AS IS" BASIS,// * See the License for the specific language governing permissions and// * limitations under the License.// */////package io.shulie.tro.web.app.service.fastdebug;////import java.io.BufferedReader;//import java.io.File;//import java.io.IOException;//import java.io.StringReader;//import java.net.HttpURLConnection;//import java.net.URL;//import java.nio.charset.Charset;//import java.nio.charset.StandardCharsets;//import java.util.Arrays;//import java.util.Collections;//import java.util.List;//import java.util.Map;//import java.util.Objects;//import java.util.Optional;//import java.util.Set;//import java.util.concurrent.ThreadPoolExecutor;//import java.util.concurrent.atomic.AtomicBoolean;//import java.util.concurrent.atomic.AtomicInteger;//import java.util.function.Function;//import java.util.stream.Collectors;////import com.fasterxml.jackson.core.type.TypeReference;//import com.google.common.collect.BiMap;//import com.google.common.collect.HashBiMap;//import com.google.common.collect.Lists;//import com.google.common.collect.Maps;//import com.google.common.collect.Sets;//import com.pamirs.pradar.MiddlewareType;//import com.pamirs.pradar.Pradar;//import com.pamirs.pradar.ResultCode;//import com.pamirs.pradar.log.parser.trace.RpcBased;//import com.pamirs.pradar.log.parser.trace.RpcEntry;//import com.pamirs.pradar.log.parser.trace.RpcStack;//import com.pamirs.tro.common.constant.LogLevelEnum;//import com.pamirs.tro.common.constant.VerifyResultStatusEnum;//import com.pamirs.tro.common.util.DateUtils;//import com.pamirs.tro.entity.domain.entity.user.User;//import com.pamirs.tro.entity.domain.vo.linkmanage.BusinessLinkVo;//import io.shulie.tro.common.beans.page.PagingList;//import io.shulie.tro.constants.TroRequestConstant;//import io.shulie.tro.utils.file.FileManagerHelper;//import io.shulie.tro.utils.json.JsonHelper;//import io.shulie.tro.web.amdb.api.TraceClient;//import io.shulie.tro.web.app.common.RestContext;//import io.shulie.tro.web.app.constant.BizOpConstants.Vars;//import io.shulie.tro.web.app.context.OperationLogContextHolder;//import io.shulie.tro.web.app.exception.ExceptionCode;//import io.shulie.tro.web.app.exception.TroWebException;//import io.shulie.tro.web.app.input.fastdebug.FastDebugCallStackDetailSearchInput;//import io.shulie.tro.web.app.input.fastdebug.FastDebugConfigCreateInput;//import io.shulie.tro.web.app.input.fastdebug.FastDebugConfigSearchInput;//import io.shulie.tro.web.app.input.fastdebug.FastDebugConfigUpdateInput;//import io.shulie.tro.web.app.input.fastdebug.FastDebugExceptionSearchInput;//import io.shulie.tro.web.app.input.fastdebug.FastDebugResultSearchInput;//import io.shulie.tro.web.app.output.fastdebug.FastDebugCallStackDetailOutput;//import io.shulie.tro.web.app.output.fastdebug.FastDebugConfigDetailOutput;//import io.shulie.tro.web.app.output.fastdebug.FastDebugConfigLeakSqlOutput;//import io.shulie.tro.web.app.output.fastdebug.FastDebugExceptionOutput;//import io.shulie.tro.web.app.output.fastdebug.FastDebugLocateCallstackOutput;//import io.shulie.tro.web.app.output.fastdebug.FastDebugResultDetailOutput;//import io.shulie.tro.web.app.output.fastdebug.FastDebugResultLeakSqlOutput;//import io.shulie.tro.web.app.output.fastdebug.FastDebugResultOutput;//import io.shulie.tro.web.app.output.fastdebug.FastDebugStackInfoOutPut;//import io.shulie.tro.web.app.request.leakcheck.LeakSqlBatchRefsRequest;//import io.shulie.tro.web.app.request.leakverify.LeakVerifyTaskRunWithoutSaveRequest;//import io.shulie.tro.web.app.response.leakcheck.LeakSqlBatchRefsResponse;//import io.shulie.tro.web.app.response.leakverify.LeakVerifyTaskResultResponse;//import io.shulie.tro.web.app.service.LeakSqlService;//import io.shulie.tro.web.app.service.VerifyTaskService;//import io.shulie.tro.web.app.utils.ExcelUtil;//import io.shulie.tro.web.common.constant.TraceNodeConstant;//import io.shulie.tro.web.common.enums.application.AppExceptionCodeEnum;//import io.shulie.tro.web.common.enums.fastdebug.CallStackExceptionEnum;//import io.shulie.tro.web.common.enums.fastdebug.FastDebugEnum;//import io.shulie.tro.web.common.enums.fastdebug.FastDebugErrorEnum;//import io.shulie.tro.web.common.enums.fastdebug.FastDebugResultEnum;//import io.shulie.tro.web.common.vo.component.CascaderVO;//import io.shulie.tro.web.common.vo.excel.ExcelExceptionVO;//import io.shulie.tro.web.common.vo.fastdebug.ContentTypeVO;//import io.shulie.tro.web.common.vo.fastdebug.DebugResponseVO;//import io.shulie.tro.web.common.vo.fastdebug.FastDebugCallStackExceptionVO;//import io.shulie.tro.web.common.vo.fastdebug.FastDebugCallStackVO;//import io.shulie.tro.web.common.vo.fastdebug.FastDebugCallstackAnalysisVO;//import io.shulie.tro.web.common.vo.fastdebug.FastDebugExceptionVO;//import io.shulie.tro.web.common.vo.fastdebug.FastDebugNodeExceptionVO;//import io.shulie.tro.web.common.vo.fastdebug.LeakSqlResultVO;//import io.shulie.tro.web.common.vo.fastdebug.TraceNodeVO;//import io.shulie.tro.web.data.dao.application.ApplicationDAO;//import io.shulie.tro.web.data.dao.application.ApplicationNodeDAO;//import io.shulie.tro.web.data.dao.exception.ExceptionDao;//import io.shulie.tro.web.data.dao.fastdebug.FastDebugDao;//import io.shulie.tro.web.data.dao.fastdebug.FastDebugStackInfoDao;//import io.shulie.tro.web.data.dao.linkmanage.BusinessLinkManageDAO;//import io.shulie.tro.web.data.dao.tracenode.TraceNodeDao;//import io.shulie.tro.web.data.dao.user.TroUserDAO;//import io.shulie.tro.web.data.param.application.ApplicationNodeQueryParam;//import io.shulie.tro.web.data.param.exception.ExceptionParam;//import io.shulie.tro.web.data.param.fastdebug.FastDebugConfigCreateParam;//import io.shulie.tro.web.data.param.fastdebug.FastDebugConfigSearchParam;//import io.shulie.tro.web.data.param.fastdebug.FastDebugConfigUpdateParam;//import io.shulie.tro.web.data.param.fastdebug.FastDebugExceptionParam;//import io.shulie.tro.web.data.param.fastdebug.FastDebugExceptionSearchParam;//import io.shulie.tro.web.data.param.fastdebug.FastDebugResultParam;//import io.shulie.tro.web.data.param.fastdebug.FastDebugResultSearchParam;//import io.shulie.tro.web.data.param.fastdebug.FastDebugResultUpdateParam;//import io.shulie.tro.web.data.param.fastdebug.FastDebugStackInfoQueryParam;//import io.shulie.tro.web.data.param.tracenode.TraceNodeInfoParam;//import io.shulie.tro.web.data.result.application.ApplicationDetailResult;//import io.shulie.tro.web.data.result.application.ApplicationNodeResult;//import io.shulie.tro.web.data.result.application.ApplicationResult;//import io.shulie.tro.web.data.result.application.InstanceInfoResult;//import io.shulie.tro.web.data.result.exception.ExceptionResult;//import io.shulie.tro.web.data.result.fastdebug.FastDebugConfigResult;//import io.shulie.tro.web.data.result.fastdebug.FastDebugResult;//import io.shulie.tro.web.data.result.fastdebug.FastDebugStackInfoResult;//import io.shulie.tro.web.data.result.linkmange.BusinessLinkResult;//import io.shulie.tro.web.data.result.tracenode.TraceNodeInfoResult;//import io.shulie.tro.web.data.result.user.TroUserResult;//import io.shulie.tro.web.data.result.user.UserCommonResult;//import lombok.extern.slf4j.Slf4j;//import org.apache.commons.collections4.CollectionUtils;//import org.apache.commons.lang3.StringUtils;//import org.apache.http.annotation.Contract;//import org.apache.http.annotation.ThreadingBehavior;//import org.apache.http.client.HttpClient;//import org.apache.http.client.methods.HttpDelete;//import org.apache.http.client.methods.HttpGet;//import org.apache.http.client.methods.HttpPost;//import org.apache.http.client.methods.HttpPut;//import org.apache.http.impl.client.DefaultRedirectStrategy;//import org.apache.http.impl.client.HttpClientBuilder;//import org.springframework.beans.BeanUtils;//import org.springframework.beans.factory.annotation.Autowired;//import org.springframework.beans.factory.annotation.Qualifier;//import org.springframework.beans.factory.annotation.Value;//import org.springframework.http.HttpEntity;//import org.springframework.http.HttpHeaders;//import org.springframework.http.HttpMethod;//import org.springframework.http.HttpStatus;//import org.springframework.http.MediaType;//import org.springframework.http.ResponseEntity;//import org.springframework.http.client.ClientHttpResponse;//import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;//import org.springframework.http.client.SimpleClientHttpRequestFactory;//import org.springframework.http.converter.StringHttpMessageConverter;//import org.springframework.stereotype.Service;//import org.springframework.transaction.annotation.Transactional;//import org.springframework.web.client.ResponseErrorHandler;//import org.springframework.web.client.RestTemplate;/////**// * @author 无涯// * @Package io.shulie.tro.web.app.service.fastdebug// * @date 2020/12/28 9:46 上午// *///@Service//@Slf4j//public class FastDebugServiceImpl implements FastDebugService {//    @Autowired//    @Qualifier("fastDebugThreadPool")//    protected ThreadPoolExecutor fastDebugExecutor;//    @Autowired//    private FastDebugDao fastDebugDao;//    @Autowired//    private TroUserDAO troUserDAO;//    @Autowired//    private TraceNodeDao traceNodeDao;//    @Autowired//    private TraceClient traceClient;//    @Autowired//    private ApplicationDAO applicationDAO;//    @Autowired//    private ApplicationNodeDAO applicationNodeDAO;//    @Autowired//    private BusinessLinkManageDAO businessLinkManageDAO;//    @Autowired//    private FastDebugAgentUploadService fastDebugAgentUploadService;//    @Value("${fast.debug.call.stack.path:/data/fastdebug/callstack}")//    private String callStackPath;//    @Value("${fast.debug.sleep.time.second:10}")//    private String time;//    @Value("${fast.debug.watch.time.second:120}")//    private String watchTime;//    @Autowired//    private ExceptionDao exceptionDao;////    @Autowired//    private FastDebugStackInfoDao fastDebugStackInfoDao;////    @Autowired//    private LeakSqlService leakSqlService;////    @Autowired//    private VerifyTaskService verifyTaskService;////    @Override//    @Transactional(rollbackFor = Exception.class)//    public Long createFastDebugConfig(FastDebugConfigCreateInput input) {//        return saveConfig(input);//    }////    private Long saveConfig(FastDebugConfigCreateInput input) {//        // 判断是否有重名//        FastDebugConfigResult result = fastDebugDao.selectByName(input.getName());//        if (result != null) {//            throw new TroWebException(ExceptionCode.FAST_DEBUG_PARAM_NAME_ERROR, input.getName() + "已存在");//        }//        FastDebugConfigCreateParam param = new FastDebugConfigCreateParam();//        BeanUtils.copyProperties(input, param);//        User user = RestContext.getUser();//        param.setCreatorId(Optional.ofNullable(user).map(User::getId).orElse(null));//        param.setModifierId(Optional.ofNullable(user).map(User::getId).orElse(null));//        param.setContentType(JsonHelper.bean2Json(input.getContentTypeVo()));//        param.setCustomerId(RestContext.getCustomerId());//        return fastDebugDao.createFastDebugConfig(param);//    }////    @Override//    @Transactional(rollbackFor = Exception.class)//    public void deleteFastDebugConfig(Long id) {//        FastDebugConfigResult result = fastDebugDao.selectById(id);//        Optional.ofNullable(result)//            .orElseThrow(() -> new TroWebException(ExceptionCode.FAST_DEBUG_DELETE_ERROR, id + "不存在"));////        if (!RestContext.getCustomerId().equals(result.getCustomerId())) {//            throw new TroWebException(ExceptionCode.FAST_DEBUG_DELETE_ERROR, "不能跨租户删除");//        }//        if (result.getStatus().equals(FastDebugEnum.STARTING.getStatus())) {//            throw new TroWebException(ExceptionCode.FAST_DEBUG_DELETE_ERROR, result.getName() + "正在调试中，不能删除");//        }//        fastDebugDao.deleteFastDebugConfig(id);//        OperationLogContextHolder.addVars(Vars.FAST_DEBUG_CONFIG_ID, String.valueOf(result.getId()));//        OperationLogContextHolder.addVars(Vars.FAST_DEBUG_CONFIG_NAME, String.valueOf(result.getName()));//    }////    @Override//    @Transactional(rollbackFor = Exception.class)//    public void updateFastDebugConfig(FastDebugConfigUpdateInput input) {//        updateConfig(input);//    }////    private void updateConfig(FastDebugConfigUpdateInput input) {//        // 判断是否有重名//        FastDebugConfigResult result = fastDebugDao.selectById(input.getId());//        if (!StringUtils.equals(result.getName(), input.getName())) {//            throw new TroWebException(ExceptionCode.FAST_DEBUG_PARAM_NAME_ERROR, "名称不允许修改");//        }//        // 业务活动不允许修改//        if (!input.getBusinessLinkId().equals(result.getBusinessLinkId())) {//            throw new TroWebException(ExceptionCode.FAST_DEBUG_PARAM_NAME_ERROR, "业务活动不允许修改");//        }////        if (!RestContext.getCustomerId().equals(result.getCustomerId())) {//            throw new TroWebException(ExceptionCode.FAST_DEBUG_PARAM_NAME_ERROR, "不能跨租户修改");//        }//        FastDebugConfigUpdateParam param = new FastDebugConfigUpdateParam();//        BeanUtils.copyProperties(input, param);//        param.setModifierId(Optional.ofNullable(RestContext.getUser()).map(User::getId).orElse(null));//        param.setContentType(JsonHelper.bean2Json(input.getContentTypeVo()));//        fastDebugDao.updateFastDebugConfig(param);//    }////    @Override//    public FastDebugConfigDetailOutput selectById(Long id) {//        FastDebugConfigResult result = fastDebugDao.selectById(id);//        Optional.ofNullable(result).orElseThrow(() -> new TroWebException(ExceptionCode.FAST_SEARCH_ERROR, id + "不存在"));//        FastDebugConfigDetailOutput output = new FastDebugConfigDetailOutput();//        output.setStatus(FastDebugEnum.getDescByStatus(result.getStatus()));//        TroUserResult troUserResult = troUserDAO.selectById(result.getModifierId());//        output.setModifierName(Optional.ofNullable(troUserResult).map(TroUserResult::getName).orElse(""));//        output.setGmtModified(DateUtils.dateToString(result.getGmtModified(), DateUtils.FORMATE_YMDHMS));//        BeanUtils.copyProperties(result, output);//        return output;//    }////    @Override//    public List<FastDebugConfigLeakSqlOutput> getLeakageCheckData(Long businessLinkId) {////        LeakSqlBatchRefsRequest refsRequest = new LeakSqlBatchRefsRequest();//        List<Long> businessActivityIds = Lists.newArrayList();//        businessActivityIds.add(businessLinkId);//        refsRequest.setBusinessActivityIds(businessActivityIds);//        List<LeakSqlBatchRefsResponse> responses = leakSqlService.getBatchLeakCheckConfig(refsRequest);//        List<FastDebugConfigLeakSqlOutput> outputs = Lists.newArrayList();//        if (responses != null && responses.size() > 0) {//            responses.forEach(response -> {//                FastDebugConfigLeakSqlOutput output = new FastDebugConfigLeakSqlOutput();//                output.setName(response.getDatasourceName());//                output.setJdbcUrl(response.getJdbcUrl());//                if (response.getSqlResponseList() != null && response.getSqlResponseList().size() > 0) {//                    List<LeakSqlResultVO> vos = response.getSqlResponseList().stream().map(sqlResponse -> {//                        LeakSqlResultVO vo = new LeakSqlResultVO();//                        BeanUtils.copyProperties(sqlResponse, vo);//                        return vo;//                    }).collect(Collectors.toList());//                    output.setVos(vos);//                }//                outputs.add(output);//            });//        }//        return outputs;//    }////    @Override//    public PagingList<FastDebugConfigDetailOutput> selectList(FastDebugConfigSearchInput input) {//        FastDebugConfigSearchParam param = new FastDebugConfigSearchParam();//        BeanUtils.copyProperties(input, param);//        param.setCustomerId(RestContext.getCustomerId());//        PagingList<FastDebugConfigResult> pagingList = fastDebugDao.selectList(param);//        if (pagingList.isEmpty()) {//            return PagingList.empty();//        }//        List<Long> resultIds = pagingList.getList().stream().map(FastDebugConfigResult::getBusinessLinkId).collect(//            Collectors.toList());//        List<BusinessLinkResult> results = businessLinkManageDAO.getListByIds(resultIds);//        Map<Long, BusinessLinkResult> businessLinkMap = results.stream().collect(//            Collectors.toMap(BusinessLinkResult::getLinkId, Function.identity()));////        List<Long> ids = pagingList.getList().stream().map(FastDebugConfigResult::getModifierId).collect(//            Collectors.toList());//        Map<Long, UserCommonResult> troUserResult = Maps.newHashMap();//        if (CollectionUtils.isNotEmpty(ids)) {//            troUserResult = troUserDAO.selectUserMapByIds(ids);//        }//        Map<Long, UserCommonResult> finalTroUserResult = troUserResult;//        List<FastDebugConfigDetailOutput> outputs = pagingList.getList().stream().map(result -> {//            FastDebugConfigDetailOutput output = new FastDebugConfigDetailOutput();//            BeanUtils.copyProperties(result, output);//            output.setStatus(FastDebugEnum.getDescByStatus(result.getStatus()));//            output.setModifierName(Optional.ofNullable(finalTroUserResult.get(result.getModifierId()))//                .map(UserCommonResult::getUserName).orElse(""));//            output.setBusinessLinkVo(Optional.ofNullable(businessLinkMap.get(result.getBusinessLinkId()))//                .map(linkResult -> {//                    BusinessLinkVo vo = new BusinessLinkVo();//                    BeanUtils.copyProperties(linkResult, vo);//                    return vo;//                }).orElseGet(() -> new BusinessLinkVo()));//            output.setGmtModified(DateUtils.dateToString(result.getGmtModified(), DateUtils.FORMATE_YMDHMS));//            return output;//        }).collect(Collectors.toList());//        return PagingList.of(outputs, pagingList.getTotal());//    }////    @Override//    public PagingList<FastDebugResultOutput> selectDebugList(FastDebugResultSearchInput input) {////        FastDebugResultSearchParam param = new FastDebugResultSearchParam();//        BeanUtils.copyProperties(input, param);//        param.setCustomerId(RestContext.getCustomerId());//        PagingList<FastDebugResult> pagingList = fastDebugDao.selectDebugList(param);//        if (pagingList.isEmpty()) {//            return PagingList.empty();//        }////        List<Long> ids = pagingList.getList().stream().map(FastDebugResult::getCreatorId).collect(Collectors.toList());//        Map<Long, UserCommonResult> troUserResult = Maps.newHashMap();//        if (CollectionUtils.isNotEmpty(ids)) {//            troUserResult = troUserDAO.selectUserMapByIds(ids);//        }//        Map<Long, UserCommonResult> finalTroUserResult = troUserResult;//        List<FastDebugResultOutput> outputs = pagingList.getList().stream().map(result -> {//            FastDebugResultOutput output = new FastDebugResultOutput();//            BeanUtils.copyProperties(result, output);//            // 调试结果//            output.setDebugResult(Optional.ofNullable(result.getDebugResult()).map(FastDebugResultEnum::getDescByStatus)//                .orElse(FastDebugEnum.STARTING.getDesc()));//            output.setCreatorName(Optional.ofNullable(finalTroUserResult.get(result.getCreatorId()))//                .map(UserCommonResult::getUserName).orElse(""));//            output.setGmtCreate(DateUtils.dateToString(result.getGmtCreate(), DateUtils.FORMATE_YMDHMS));//            return output;//        }).collect(Collectors.toList());//        return PagingList.of(outputs, pagingList.getTotal());//    }////    @Override//    public FastDebugResultDetailOutput selectDebugById(Long id) {//        FastDebugResultDetailOutput output = new FastDebugResultDetailOutput();////        FastDebugResult result = fastDebugDao.selectDebugResultById(id);//        Optional.ofNullable(result)//            .orElseThrow(() -> new TroWebException(ExceptionCode.FAST_SEARCH_ERROR, id + "不存在"));//        BeanUtils.copyProperties(result, output);//        // 解析//        try {//            if (StringUtils.isNotBlank(result.getErrorMessage())) {//                Map<String, String> map = JsonHelper.string2Obj(result.getErrorMessage(),//                    new TypeReference<Map<String, String>>() {});//                String errorMessage = map.get(FastDebugErrorEnum.EXCEPTION.getType());//                output.setErrorMessage(StringUtils.isNotBlank(errorMessage) ? errorMessage : "");//                // 查看漏数检查//                if (StringUtils.isNotBlank(errorMessage)) {//                    String flag = String.format(FastDebugErrorEnum.LEAK_VERIFY_EXCEPTION.getErrorName(), "");//                    output.setIsLeakException(errorMessage.contains(flag));//                }//                // 调用栈分析结果展示//                List<FastDebugCallstackAnalysisVO> callstackMessage = getCallStackMessage(map);//                output.setCallStackMessage(callstackMessage);//            }//        } catch (Exception e) {//            e.printStackTrace();//        }////        TroUserResult userResult = troUserDAO.selectById(result.getCreatorId());//        Long customerId = Optional.ofNullable(userResult).map(TroUserResult::getCustomerId).orElse(0L);//        output.setCreatorName(Optional.ofNullable(userResult).map(TroUserResult::getName).orElse(""));//        output.setStatus(Optional.ofNullable(result.getDebugResult()).map(FastDebugResultEnum::getDescByStatus)//            .orElse(FastDebugEnum.STARTING.getDesc()));//        HttpEntity<String> httpEntity = JsonHelper.string2Obj(result.getRequest(),//            new TypeReference<HttpEntity<String>>() {});//        if (StringUtils.isNotBlank(result.getResponse())) {//            DebugResponseVO vo = JsonHelper.string2Obj(result.getResponse(), DebugResponseVO.class);//            output.setResponseCode(String.valueOf(vo.getStatusCodeValue()));//            output.setResponse(vo);//        } else {//            DebugResponseVO debugResponseVO = new DebugResponseVO();//            debugResponseVO.setHeaders(new HttpHeaders());//            output.setResponse(debugResponseVO);//            output.setResponseCode("-");//        }//        output.setRequest(httpEntity);//        output.setRequestTime(DateUtils.dateToString(result.getGmtCreate(), DateUtils.FORMATE_YMDHMS));////        // 查看调用栈异常个数//        if (StringUtils.isNotBlank(result.getTraceId())) {//            // 查看配置异常个数//            output.setExceptionCount(fastDebugDao.getExceptionCount(result.getTraceId(), customerId, ""));//            //Long callStackErrorCount = fastDebugAgentUploadService.hasStackErrorLog(result.getTraceId());//            // 异常节点//            Long exceptionCount = traceNodeDao.getExceptionNodeCount(result.getTraceId(), customerId);//            // 未知节点//            Long unknownNodeCount = traceNodeDao.getUnknownNodeCount(result.getTraceId(), customerId);//            output.setCallStackExceptionCount(exceptionCount + unknownNodeCount);//        }////        return output;//    }////    private List<FastDebugCallstackAnalysisVO> getCallStackMessage(Map<String, String> map) {//        List<FastDebugCallstackAnalysisVO> vos = Lists.newArrayList();////        Integer exceptionNodeCount = Integer.parseInt(//            Optional.ofNullable(map.get(FastDebugErrorEnum.CALLSTACK_EXCEPTION_NODE.getType())).orElse("0"));//        Integer unknownNodeCount = Integer.parseInt(//            Optional.ofNullable(map.get(FastDebugErrorEnum.CALLSTACK_UNKNOWN_NODE.getType())).orElse("0"));////        vos.add(new FastDebugCallstackAnalysisVO(CallStackExceptionEnum.NODE_UNKNOWN, unknownNodeCount));//        vos.add(new FastDebugCallstackAnalysisVO(CallStackExceptionEnum.NODE_EXCEPTION, exceptionNodeCount));//        // 其他异常//        Integer lostNodeCount = Integer.parseInt(//            Optional.ofNullable(map.get(FastDebugErrorEnum.CALLSTACK_LOST_NODE.getType())).orElse("0"));//        Integer signExceptionNodeCount = Integer.parseInt(//            Optional.ofNullable(map.get(FastDebugErrorEnum.CALLSTACK_SIGN_EXCEPTION_NODE.getType())).orElse("0"));//        vos.add(new FastDebugCallstackAnalysisVO(CallStackExceptionEnum.NODE_OTHER_EXCEPTION,//            lostNodeCount + signExceptionNodeCount));//        return vos;//    }////    @Override//    @Transactional(rollbackFor = Exception.class)//    public void deleteFastDebugResult(Long id) {//        FastDebugResult result = fastDebugDao.selectDebugResultById(id);//        Optional.ofNullable(result)//            .orElseThrow(() -> new TroWebException(ExceptionCode.FAST_DEBUG_DELETE_ERROR, id + "不存在"));//        if (!RestContext.getCustomerId().equals(result.getCustomerId())) {//            throw new TroWebException(ExceptionCode.FAST_DEBUG_DELETE_ERROR, "不能跨租户删除");//        }//        fastDebugDao.deleteFastDebugResultById(id);//        OperationLogContextHolder.addVars(Vars.FAST_DEBUG_CONFIG_ID, String.valueOf(result.getId()));//        OperationLogContextHolder.addVars(Vars.FAST_DEBUG_CONFIG_NAME, String.valueOf(result.getName()));//    }////    @Override//    public PagingList<FastDebugExceptionVO> getExceptionPage(FastDebugExceptionSearchInput input) {//        if (StringUtils.isBlank(input.getTraceId())) {//            return PagingList.empty();//        }//        FastDebugExceptionSearchParam param = new FastDebugExceptionSearchParam();//        BeanUtils.copyProperties(input, param);//        param.setCustomerId(RestContext.getCustomerId());//        return fastDebugDao.getExceptionPage(param);//    }////    @Override//    public FastDebugExceptionOutput getExceptionSearch(FastDebugExceptionSearchInput input) {//        if (StringUtils.isBlank(input.getTraceId())) {//            return new FastDebugExceptionOutput();//        }//        List<FastDebugExceptionVO> results = fastDebugDao.getException(input.getTraceId(), "", "", "");//        List<String> apps = results.stream().map(FastDebugExceptionVO::getApplicationName).distinct().collect(//            Collectors.toList());//        List<String> codes = results.stream().map(FastDebugExceptionVO::getCode).distinct().collect(//            Collectors.toList());//        List<String> types = results.stream().map(FastDebugExceptionVO::getType).distinct().collect(//            Collectors.toList());//        return new FastDebugExceptionOutput(apps, codes, types);//    }////    @Override//    public List<CascaderVO> getExamples(String traceId) {//        FastDebugStackInfoQueryParam param = new FastDebugStackInfoQueryParam();//        param.setTraceId(traceId);//        List<FastDebugStackInfoResult> results = fastDebugStackInfoDao.selectByExample(param);//        if (results.size() > 0) {//            return results.stream().map(FastDebugStackInfoResult::getAppName).distinct()//                .filter(StringUtils::isNotEmpty).map(appName -> {//                    CascaderVO vo = new CascaderVO();//                    vo.setLabel(appName);//                    vo.setValue(appName);//                    vo.setChildren(//                        results.stream()//                            .filter(t -> appName.equals(t.getAppName()))//                            .map(FastDebugStackInfoResult::getAgentId).distinct()//                            .filter(StringUtils::isNotEmpty)//                            .map(agentId -> {//                                CascaderVO agentVo = new CascaderVO();//                                agentVo.setLabel(agentId);//                                agentVo.setValue(agentId);//                                return agentVo;//                            }).collect(Collectors.toList())//                    );//                    return vo;//                }).collect(Collectors.toList());//        }//        // 兜底//        List<TraceNodeInfoResult> nodeInfoResults = traceNodeDao.getNodeList(traceId, RestContext.getCustomerId());//        return nodeInfoResults.stream().map(TraceNodeInfoResult::getAppName).distinct().map(appName -> {//            CascaderVO vo = new CascaderVO();//            vo.setLabel(appName);//            vo.setValue(appName);//            vo.setChildren(//                nodeInfoResults.stream()//                    .filter(t -> appName.equals(t.getAppName()))//                    .map(TraceNodeInfoResult::getAgentId).distinct()//                    .map(agentId -> {//                        CascaderVO agentVo = new CascaderVO();//                        agentVo.setLabel(agentId);//                        agentVo.setValue(agentId);//                        return agentVo;//                    }).collect(Collectors.toList())//            );//            return vo;//        }).collect(Collectors.toList());//    }////    @Override//    @Transactional(rollbackFor = Exception.class)//    public Long debug(Long id) {//        // 发出请求//        FastDebugConfigResult result = fastDebugDao.selectById(id);//        if (FastDebugEnum.STARTING.getStatus().equals(result.getStatus())) {//            throw new TroWebException(ExceptionCode.FAST_DEBUG_ERROR, result.getName() + "正在调试中，请等调试结束后再开始调试");//        }//        BusinessLinkResult businessLinkResult = businessLinkManageDAO.selectBussinessLinkById(//            result.getBusinessLinkId());//        if (businessLinkResult == null || businessLinkResult.getId() == null) {//            throw new TroWebException(ExceptionCode.FAST_DEBUG_ERROR, "业务活动" + result.getBusinessLinkId() + "不存在");//        }////        FastDebugResultParam param = new FastDebugResultParam();//        param.setName(result.getName());//        param.setConfigId(result.getId());//        param.setRequestUrl(result.getRequestUrl());//        Long customerId = RestContext.getCustomerId();//        param.setCustomerId(customerId);//        param.setHttpMethod(result.getHttpMethod());//        param.setBusinessLinkName(businessLinkResult.getLinkName());//        param.setCreatorId(Optional.ofNullable(RestContext.getUser()).orElseGet(User::new).getId());//        FastDebugResult fastDebugResult = fastDebugDao.insertDebugResult(param);//        // 异步发出请求//        fastDebugExecutor.execute(() -> sendHttp(result, fastDebugResult, customerId));//        OperationLogContextHolder.addVars(Vars.FAST_DEBUG_CONFIG_NAME, String.valueOf(result.getName()));//        return fastDebugResult.getId();//    }////    private RestTemplate createRestTemplate(FastDebugConfigResult result) {//        RestTemplate restTemplate = null;//        if (result.getIsRedirect()) {//            // 重定向//            HttpComponentsClientHttpRequestFactory httpRequestFactory = new HttpComponentsClientHttpRequestFactory();//            httpRequestFactory.setConnectionRequestTimeout(3000);//            //客服端发送请求到与目标url建立起连接的最大时间//            httpRequestFactory.setConnectTimeout(3000);//            // 读取超时//            httpRequestFactory.setReadTimeout(result.getTimeout());//            HttpClient httpClient = HttpClientBuilder.create().setRedirectStrategy(new MyRedirectStrategy()).build();//            httpRequestFactory.setHttpClient(httpClient);//            restTemplate = new RestTemplate(httpRequestFactory);//        } else {//            NoRedirectClientHttpRequestFactory factory = new NoRedirectClientHttpRequestFactory();//            // 读取超时//            factory.setConnectTimeout(3000);//            factory.setReadTimeout(result.getTimeout());//            restTemplate = new RestTemplate(factory);//        }////        // 设置编码//        restTemplate.getMessageConverters().set(1,//            new StringHttpMessageConverter("GBK".equals(result.getContentTypeVo().getCodingFormat().toUpperCase())//                ? Charset.forName("GBK") : StandardCharsets.UTF_8));//        restTemplate.setErrorHandler(new MyRestErrorHandler());//        return restTemplate;//    }////    private void updateDebugResult(FastDebugResultUpdateParam updateParam) {//        updateParam.setDebugResult(checkError(updateParam.getErrorMessage()) ? FastDebugResultEnum.ERROR.getStatus() ://            FastDebugResultEnum.SUCCESS.getStatus());//        fastDebugDao.updateFastDebugResult(updateParam);//        // 配置更新//        FastDebugConfigUpdateParam configUpdateParam = new FastDebugConfigUpdateParam();//        configUpdateParam.setId(updateParam.getConfigId());//        configUpdateParam.setStatus(FastDebugEnum.FREE.getStatus());//        fastDebugDao.updateFastDebugConfig(configUpdateParam);//    }////    private boolean checkError(String errorMessage) {//        // 解析error//        Map<String, String> map = Maps.newHashMap();//        if (StringUtils.isNotBlank(errorMessage)) {//            try {//                map = JsonHelper.string2Obj(errorMessage, new TypeReference<Map<String, String>>() {});//            } catch (Exception e) {//                log.error("Json解析失败{}", e.getLocalizedMessage());//            }//        }//        return map.containsKey(FastDebugErrorEnum.EXCEPTION.getType());//    }////    public void watchDebug(Long customerId, FastDebugResultUpdateParam updateParam) {//        AtomicBoolean isStop = new AtomicBoolean(true);//        new Thread(() -> {//            try {//                Thread.sleep(Integer.parseInt(watchTime) * 1000L);//            } catch (InterruptedException e) {//                e.printStackTrace();//            }//            if (isStop.get()) {//                // 超时检测//                refreshDebugErrorMessage(FastDebugErrorEnum.ANALYSIS_DATA_TIMEOUT, updateParam, "");//                updateDebugResult(updateParam);//            }//        }).start();//        // 监控agent10s内是否有数据上报//        Boolean flag = true;//        long start = System.currentTimeMillis();//        do {//            //计数//            Integer oldCount = fastDebugAgentUploadService.getStackUploadTimes(updateParam.getTraceId());//            try {//                // 10s可能更合理//                Thread.sleep(Integer.parseInt(time) * 1000);//            } catch (InterruptedException e) {//                e.printStackTrace();//            }//            Integer newCount = fastDebugAgentUploadService.getStackUploadTimes(updateParam.getTraceId());//            if (oldCount.equals(newCount)) {//                flag = false;//            }//        } while (flag);//        long watch = System.currentTimeMillis();//        log.info("{}监听agent上传时间:{}", updateParam.getId(), watch - start);//        fastDebugAgentUploadService.deleteStackUploadTimesKey(updateParam.getTraceId());//        try {//            // 保存调用栈信息 本地保存数据//            saveRpcStack(updateParam.getTraceId(), customerId);//            long saveStack = System.currentTimeMillis();//            log.info("{}保存调用栈时间:{}", updateParam.getId(), saveStack - watch);//            Set<String> apps = Sets.newHashSet();//            // 保存节点，同时解析应用，agentId，rpcId//            saveNodeData(updateParam.getTraceId(), customerId);//            long saveNode = System.currentTimeMillis();//            log.info("{}保存调用栈节点时间:{}", updateParam.getId(), saveNode - saveStack);//            // 获取appName//            getAppNames(apps, updateParam.getTraceId());//            // 应用在线节点数与节点总数//            saveAgentNodeException(Lists.newArrayList(apps), updateParam, customerId);//            // 漏数检查无数据漏数//            saveCheckLeakageDataException(updateParam);//            // agent版本信息比对一致//            saveAgentVersionException(Lists.newArrayList(apps), updateParam, customerId);//            //agent上报节点和调用栈统计Agent节点保持一致 上报节点个数//            checkAgentCountException(updateParam, customerId);//            //配置异常检查//            checkAppException(updateParam, customerId);//            //调用栈异常检测//            checkCallStackException(updateParam, customerId);//            // debug更新//            isStop.set(false);//        } catch (Exception e) {//            log.error("{}验证过程存在异常：{}", updateParam.getTraceId(), e.getLocalizedMessage());//            refreshDebugErrorMessage(FastDebugErrorEnum.EXCEPTION, updateParam, "");//        }//        updateDebugResult(updateParam);//        log.info("{}验证结束:{}", updateParam.getId(), System.currentTimeMillis() - start);//    }////    private void saveCheckLeakageDataException(FastDebugResultUpdateParam updateParam) {//        try {//            LeakVerifyTaskRunWithoutSaveRequest runRequest = new LeakVerifyTaskRunWithoutSaveRequest();//            runRequest.setBusinessActivityId(updateParam.getBusinessLinkId());//            LeakVerifyTaskResultResponse response = verifyTaskService.runWithoutResultSave(runRequest);//            if (!VerifyResultStatusEnum.NORMAL.getCode().equals(response.getStatus())) {//                String status = VerifyResultStatusEnum.getLabelByCode(response.getStatus());//                refreshDebugErrorMessage(FastDebugErrorEnum.LEAK_VERIFY_EXCEPTION, updateParam, status);//            }//            updateParam.setLeakageCheckData(JsonHelper.bean2Json(response));//        } catch (Exception e) {//            log.error("漏数验证失败:{}", e.getMessage());//        }//    }////    private void getAppNames(Set<String> apps, String traceId) {//        FastDebugStackInfoQueryParam param = new FastDebugStackInfoQueryParam();//        param.setTraceId(traceId);//        List<FastDebugStackInfoResult> results = fastDebugStackInfoDao.selectByExample(param);//        results.forEach(info -> apps.add(info.getAppName()));//    }////    private void checkCallStackException(FastDebugResultUpdateParam updateParam, Long customerId) {//        // agent调用栈节点异常//        Long nodeExceptionCount = fastDebugAgentUploadService.hasStackErrorLog(updateParam.getTraceId());//        Long exceptionCount = traceNodeDao.getExceptionNodeCount(updateParam.getTraceId(), customerId);//        log.info("{}:agent上报异常个数 = {},大数据异常个数 = {}", updateParam.getTraceId(), nodeExceptionCount, exceptionCount);//        // 检查是否有未知节点//        Long unknownNodeCount = traceNodeDao.getUnknownNodeCount(updateParam.getTraceId(), customerId);//        if (exceptionCount > 0 || unknownNodeCount > 0) {//            Long errorCount = exceptionCount + unknownNodeCount;//            refreshDebugErrorMessage(FastDebugErrorEnum.CALLSTACK_EXCEPTION, updateParam, errorCount);//        }////        if (exceptionCount > 0) {//            refreshDebugErrorMessage(FastDebugErrorEnum.CALLSTACK_EXCEPTION_NODE, updateParam, exceptionCount);//        }//        if (unknownNodeCount > 0) {//            refreshDebugErrorMessage(FastDebugErrorEnum.CALLSTACK_UNKNOWN_NODE, updateParam, unknownNodeCount);//        }//        // 计算节点标识异常//        List<TraceNodeInfoResult> infoResults = traceNodeDao.getNodeList(updateParam.getTraceId(), customerId);//        long signExceptionCount = infoResults.stream().filter(result -> !result.getClusterTest()).count();//        if (signExceptionCount > 0) {//            // 业务流量问题//            refreshDebugErrorMessage(FastDebugErrorEnum.BUSINESS_FLOW_EXCEPTION, updateParam, signExceptionCount);//            refreshDebugErrorMessage(FastDebugErrorEnum.CALLSTACK_SIGN_EXCEPTION_NODE, updateParam, signExceptionCount);//        }//    }////    private void saveAgentNodeException(List<String> apps, FastDebugResultUpdateParam updateParam, Long customerId) {//        List<FastDebugExceptionParam> params = Lists.newArrayList();//        List<ApplicationResult> applicationResultList = applicationDAO.getApplicationByName(apps);//        List<ApplicationDetailResult> detailResults = applicationDAO.getApplicationList(apps);//        Map<String, Integer> nodeNumMap = detailResults.stream()//            .collect(Collectors.toMap(ApplicationDetailResult::getApplicationName, ApplicationDetailResult::getNodeNum,//                (k1, k2) -> k1));//        applicationResultList.forEach(app -> {//            InstanceInfoResult result = app.getInstanceInfo();//            Integer nodeNum = nodeNumMap.get(app.getAppName());//            if (!nodeNum.equals(result.getInstanceOnlineAmount())) {//                FastDebugExceptionParam param = new FastDebugExceptionParam();//                param.setResultId(updateParam.getId());//                param.setTraceId(updateParam.getTraceId());//                param.setRpcId("-");//                param.setApplicationName(app.getAppName());//                param.setCode(AppExceptionCodeEnum.EPC0001.getCode());//                param.setDescription(AppExceptionCodeEnum.EPC0001.getDesc());//                param.setTime(DateUtils.getNowDateStr());//                param.setAgentId(Arrays.asList("-"));//                if (StringUtils.isNotBlank(param.getCode())) {//                    ExceptionResult exceptionResult = exceptionDao.getByAgentCode(param.getCode());//                    param.setType(Optional.ofNullable(exceptionResult).map(ExceptionResult::getType).orElse(null));//                    param.setSuggestion(Optional.ofNullable(exceptionResult).map(ExceptionResult::getSuggestion)//                        .orElse(null));//                }//                param.setCustomerId(customerId);//                params.add(param);//            }//        });//        fastDebugDao.batchInsertException(params);//    }////    private void checkAgentCountException(FastDebugResultUpdateParam updateParam, Long customerId) {//        // rpc节点数//        Integer rpcCount = traceNodeDao.getNodeCount(updateParam.getTraceId(), customerId);//        // agent上报次数//        FastDebugStackInfoQueryParam param = new FastDebugStackInfoQueryParam();//        param.setTraceId(updateParam.getTraceId());//        param.setIsStack(true);//        Long newCount = fastDebugStackInfoDao.selectByExampleCount(param);//        if (!rpcCount.equals(Integer.valueOf(newCount.toString()))) {//            // 查出不一致的节点数//            log.error("{}:agent上报节点与调用栈节点数不一致", updateParam.getTraceId());//            List<TraceNodeInfoResult> nodeInfoResults = traceNodeDao.getNodeList(updateParam.getTraceId(), customerId);//            List<String> nodeRpcIds = nodeInfoResults.stream().map(nodeInfo ->//                getNodeString(nodeInfo.getRpcId(), nodeInfo.getLogType(),//                    nodeInfo.getAppName(), nodeInfo.getAgentId(),nodeInfo.getTraceId()))//                .distinct().collect(Collectors.toList());//            List<FastDebugStackInfoResult> stackInfoResults = fastDebugStackInfoDao.selectByExample(param);//            List<String> errors = stackInfoResults.stream()//                .filter(info -> info.getLevel().equals(LogLevelEnum.ERROR.getName()))//                .map(nodeInfo -> getNodeString(nodeInfo.getRpcId(), nodeInfo.getType(),//                    nodeInfo.getAppName(), nodeInfo.getAgentId(),nodeInfo.getTraceId())).distinct()//                .filter(rpcId -> !nodeRpcIds.contains(rpcId))//                // 20210303：客户端不去除//                //.filter(this::isService)//                .collect(Collectors.toList());////            List<String> all = stackInfoResults.stream()//                .map(nodeInfo -> getNodeString(nodeInfo.getRpcId(), nodeInfo.getType(),//                    nodeInfo.getAppName(), nodeInfo.getAgentId(),nodeInfo.getTraceId())).distinct()//                .filter(rpcId -> !nodeRpcIds.contains(rpcId))//                //.filter(this::isService)//                .collect(Collectors.toList());//            // 计算个数//            int lostNodes = errors.size() + (int)(all.stream().filter(t -> !errors.contains(t)).count());//            refreshDebugErrorMessage(FastDebugErrorEnum.CALLSTACK_LOST_NODE, updateParam, lostNodes);//            // 显示缺少节点详情//            Map<String, List<TraceNodeVO>> resultMap = Maps.newHashMap();//            resultMap.put("error", errors.stream().map(this::getTraceNode).collect(Collectors.toList()));//            resultMap.put("success", all.stream().filter(t -> !errors.contains(t))//                .map(this::getTraceNode).collect(Collectors.toList()));//            refreshDebugErrorMessage(FastDebugErrorEnum.CALLSTACK_LOST_NODE_DETAIL, updateParam,//                JsonHelper.bean2Json(resultMap));////        }//    }////    private String getNodeString(String rpcId, Integer type, String appName, String agentId,String traceId) {//        return (rpcId + "|" + type + "|" + appName + "|" + agentId + "|" + traceId).trim();//    }////    private boolean isService(String rpcId) {//        TraceNodeVO vo = getTraceNode(rpcId);//        return TraceNodeConstant.LOG_TYPE_RPC_SERVER == Integer.parseInt(vo.getLogType());//    }////    public TraceNodeVO getTraceNode(String str) {//        String[] temp = str.split("\\|");//        TraceNodeVO vo = new TraceNodeVO();//        vo.setRpcId(temp[0]);//        vo.setLogType(temp[1]);//        vo.setAppName(temp[2]);//        vo.setAgentId(temp[3]);//        vo.setTraceId(temp[4]);//        return vo;//    }////    private void refreshDebugErrorMessage(FastDebugErrorEnum errorEnum, FastDebugResultUpdateParam updateParam, Object message) {//        if (StringUtils.isBlank(errorEnum.getErrorName())) {//            return;//        }//        String error = String.format(errorEnum.getErrorName(), message.toString());//        Map<String, String> map = Maps.newHashMap();//        if (StringUtils.isNotBlank(updateParam.getErrorMessage())) {//            map = JsonHelper.string2Obj(updateParam.getErrorMessage(), new TypeReference<Map<String, String>>() {});//        }//        map.compute(errorEnum.getType(), (k, v) -> v == null ? error : (v + "," + error));//        updateParam.setErrorMessage(JsonHelper.bean2Json(map));//    }////    private void saveRpcStack(String traceId, Long customerId) {//        RpcStack rpcStack = traceClient.getTraceDetailById(traceId);//        if (rpcStack != null) {//            FileManagerHelper.createFileByPathAndString(getFilePath(callStackPath, traceId, customerId),//                JsonHelper.bean2Json(rpcStack));//        } else {//            log.error("{}未找到调用栈", traceId);//        }//    }////    private String getFilePath(String callStackPath, String traceId, Long customerId) {//        return callStackPath + "/" + traceId + "_" + customerId + ".log";//    }////    private void saveAgentVersionException(List<String> apps, FastDebugResultUpdateParam updateParam, Long customerId) {//        if (apps == null || apps.size() == 0) {//            log.error("{}未从stack中获取到应用", updateParam.getTraceId());//            return;//        }//        ApplicationNodeQueryParam queryParam = new ApplicationNodeQueryParam();//        queryParam.setCurrent(0);//        queryParam.setPageSize(99999);//        queryParam.setApplicationNames(apps);//        PagingList<ApplicationNodeResult> applicationNodes = applicationNodeDAO.pageNodes(queryParam);//        List<ApplicationNodeResult> applicationNodeResultList = applicationNodes.getList();//        if (CollectionUtils.isNotEmpty(applicationNodeResultList)) {//            List<FastDebugExceptionParam> params = Lists.newArrayList();//            Map<String, List<ApplicationNodeResult>> listMap = applicationNodeResultList.stream().collect(//                Collectors.groupingBy(ApplicationNodeResult::getAppName));//            listMap.keySet().forEach(appName -> {//                List<String> versions = listMap.get(appName).stream().map(ApplicationNodeResult::getAgentVersion)//                    .distinct().collect(Collectors.toList());//                List<String> agentIds = listMap.get(appName).stream().map(ApplicationNodeResult::getAgentId)//                    .distinct().collect(Collectors.toList());//                if (versions.size() > 1) {//                    // 提取版本号//                    FastDebugExceptionParam param = new FastDebugExceptionParam();//                    param.setResultId(updateParam.getId());//                    param.setTraceId(updateParam.getTraceId());//                    param.setRpcId("");//                    param.setApplicationName(appName);//                    param.setCode(AppExceptionCodeEnum.EPC0002.getCode());//                    param.setDescription(AppExceptionCodeEnum.EPC0002.getDesc() + "存在版本：【" +//                        versions.stream().collect(Collectors.joining(",")) + "】");//                    param.setTime(DateUtils.getNowDateStr());//                    param.setAgentId(agentIds);//                    if (StringUtils.isNotBlank(AppExceptionCodeEnum.EPC0002.getCode())) {//                        ExceptionResult exceptionResult = exceptionDao.getByAgentCode(//                            AppExceptionCodeEnum.EPC0002.getCode());//                        param.setType(Optional.ofNullable(exceptionResult).map(ExceptionResult::getType).orElse(null));//                        param.setSuggestion(Optional.ofNullable(exceptionResult).map(ExceptionResult::getSuggestion)//                            .orElse(null));//                    }//                    param.setCustomerId(customerId);//                    params.add(param);//                }//            });//            if (params.size() > 0) {//                fastDebugDao.batchInsertException(params);//            }//        }//    }////    private void checkAppException(FastDebugResultUpdateParam updateParam, Long customerId) {//        Long exceptionCount = fastDebugDao.getExceptionCount(updateParam.getTraceId(), customerId, null);//        if (exceptionCount > 0) {//            refreshDebugErrorMessage(FastDebugErrorEnum.APP_EXCEPTION, updateParam, exceptionCount.toString());//        }//    }////    private void saveNodeData(String traceId, Long customerId) {//        List<RpcBased> rpcBasedList = traceClient.getTraceBaseById(traceId);//        List<TraceNodeInfoParam> nodeInfoParams = Lists.newArrayList();//        // 刷选所有服务端节点//        // 拼接服务端//        List<String> serviceNodes = rpcBasedList.stream()//            .filter(rpcBased -> rpcBased.getLogType() != Pradar.LOG_TYPE_RPC_CLIENT)//            .map(rpcBased -> rpcBased.getUpAppName() + "|" + rpcBased.getServiceName() + "|" + rpcBased.getMethodName())//            .collect(Collectors.toList());//        // 标识//        rpcBasedList.forEach(rpcBased -> {//            nodeInfoParams.add(getNode(rpcBased, customerId, serviceNodes));//        });//        // 节点信息保存//        traceNodeDao.batchInsert(nodeInfoParams);//    }////    private TraceNodeInfoParam getNode(RpcBased rpcBased, Long customerId, List<String> serviceNodes) {//        TraceNodeInfoParam param = new TraceNodeInfoParam();//        BeanUtils.copyProperties(rpcBased, param);//        param.setAgentId(rpcBased.getAgentId());//        param.setHostIp(rpcBased.getHostIp());//        param.setCustomerId(customerId);//        // 日志类型，客户端/服务端//        param.setLogType(rpcBased.getLogType() == Pradar.LOG_TYPE_RPC_CLIENT ? TraceNodeConstant.LOG_TYPE_RPC_CLIENT//            : TraceNodeConstant.LOG_TYPE_RPC_SERVER);//        // 未知节点判断//        param.setUnknownFlag(existUnknown(rpcBased, serviceNodes));//        return param;//    }////    private Boolean existUnknown(RpcBased rpcBased, List<String> serviceNodes) {//        // http客户端//        if (rpcBased.getLogType() == Pradar.LOG_TYPE_RPC_CLIENT//            && rpcBased.getRpcType() == MiddlewareType.TYPE_WEB_SERVER) {//            return exist(rpcBased, serviceNodes);//        }//        // dubbo客户端//        if (rpcBased.getLogType() == Pradar.LOG_TYPE_RPC_CLIENT && rpcBased.getRpcType() == MiddlewareType.TYPE_RPC//            && !rpcBased.getServiceName().toLowerCase().contains("oss")) {//            return exist(rpcBased, serviceNodes);//        }//        // mq客户端//        if (rpcBased.getLogType() == Pradar.LOG_TYPE_RPC_CLIENT && rpcBased.getRpcType() == MiddlewareType.TYPE_MQ) {//            return exist(rpcBased, serviceNodes);//        }//        return false;//    }////    private Boolean exist(RpcBased rpcBased, List<String> serviceNodes) {//        String appName = rpcBased.getAppName();//        // 格式化url//        String service = formatService(rpcBased.getServiceName(), rpcBased.getRpcType());//        String method = rpcBased.getMethodName();//        String clientKey = appName + "|" + service + "|" + method;//        if (serviceNodes.contains(clientKey)) {//            return false;//        }//        return true;//    }////    /**//     * 格式化客户端的服务名//     *//     * @return//     *///    private String formatService(String serviceName, int rpcType) {//        if (rpcType == MiddlewareType.TYPE_WEB_SERVER) {//            try {//                URL u = new URL(serviceName);//                return u.getPath();//            } catch (Throwable e) {//            }//        }//        return serviceName;//    }////    public void sendHttp(FastDebugConfigResult configResult, FastDebugResult debugResult, Long customerId) {//        FastDebugResultUpdateParam updateParam = new FastDebugResultUpdateParam();//        updateParam.setId(debugResult.getId());//        updateParam.setConfigId(debugResult.getConfigId());//        // 漏数验证用//        updateParam.setBusinessLinkId(configResult.getBusinessLinkId());//        RestTemplate restTemplate = createRestTemplate(configResult);//        long start = System.currentTimeMillis();//        try {//            HttpEntity<?> entity = null;//            ResponseEntity<String> responseEntity = null;//            if (HttpMethod.GET.name().equals(configResult.getHttpMethod().toUpperCase())) {//                entity = new HttpEntity<>(null,//                    buildHeader(configResult.getCookies(), configResult.getHeaders(), configResult.getContentTypeVo()));//                updateParam.setRequest(JsonHelper.bean2Json(entity));//                responseEntity = restTemplate.exchange(configResult.getRequestUrl(), HttpMethod.GET, entity,//                    String.class);//            } else {//                entity = new HttpEntity<>(configResult.getBody(),//                    buildHeader(configResult.getCookies(), configResult.getHeaders(), configResult.getContentTypeVo()));//                updateParam.setRequest(JsonHelper.bean2Json(entity));//                responseEntity = restTemplate.exchange(configResult.getRequestUrl(),//                    Objects.requireNonNull(HttpMethod.resolve(configResult.getHttpMethod().toUpperCase())), entity,//                    String.class);//            }//            updateParam.setCallTime(System.currentTimeMillis() - start);//            updateParam.setResponse(JsonHelper.bean2Json(responseEntity));//            // 获取traceId//            updateParam.setTraceId(getTraceId(responseEntity));//            // 错误返回//            if (!ResultCode.isOk(String.valueOf(responseEntity.getStatusCode().value()))) {//                updateParam.setError(responseEntity.getStatusCode().toString());//            }//        } catch (Exception e) {//            e.printStackTrace();//            updateParam.setCallTime(System.currentTimeMillis() - start);//            updateParam.setError(e.getLocalizedMessage());//        }//        // 请求结束，更新//        if (StringUtils.isNotBlank(updateParam.getError())) {//            refreshDebugErrorMessage(FastDebugErrorEnum.REQUEST_FAILED, updateParam, updateParam.getError());//        }//        if (StringUtils.isBlank(updateParam.getTraceId())) {//            //  兜底方案//            refreshDebugErrorMessage(FastDebugErrorEnum.REQUEST_TRACE_ID_FAILED, updateParam, "");//            updateDebugResult(updateParam);//            return;//        }//        // 开启验证过程//        fastDebugDao.updateFastDebugResult(updateParam);//        FastDebugConfigUpdateParam configUpdateParam = new FastDebugConfigUpdateParam();//        configUpdateParam.setId(configResult.getId());//        configUpdateParam.setStatus(FastDebugEnum.STARTING.getStatus());//        fastDebugDao.updateFastDebugConfig(configUpdateParam);//        // 监控数据//        watchDebug(customerId, updateParam);//    }////    private String getTraceId(ResponseEntity<String> responseEntity) {//        HttpHeaders httpHeaders = responseEntity.getHeaders();//        for (String key : httpHeaders.keySet()) {//            if ("TRACEID".equals(key.toUpperCase())) {//                List<String> list = httpHeaders.get(key);//                if (list != null && list.size() > 0) {//                    return list.get(0);//                }//            }//        }//        return "";//    }////    public HttpHeaders buildHeader(String cookies, String headers, ContentTypeVO vo) {//        HttpHeaders header = new HttpHeaders();//        // 请求头//        header.set("Content-Type", getContentType(vo));//        // 增加调试标 User-Agent:DebugPerfomanceTest//        header.add("User-Agent", TroRequestConstant.CLUSTER_TEST_HEADER_VALUE);//        header.add("p-pradar-debug", "true");//        addHeader(headers, header);//        addHeader(cookies, header);//        return header;//    }////    private void addHeader(String data, HttpHeaders header) {//        //读取行//        BufferedReader bf = new BufferedReader(new StringReader(StringUtils.isBlank(data) ? "" : data));//        String line = "";//        try {//            while ((line = bf.readLine()) != null) {//                if (StringUtils.isNotBlank(line) && line.contains(":")) {//                    String[] temp = line.split(":");//                    if (temp.length > 1) {//                        if (!("User-Agent".equals(temp[0].trim()) || "p-pradar-debug".equals(temp[0].trim()))) {//                            header.add(temp[0].trim(), temp[1].trim());//                        }//                    }//                }//            }//            bf.close();//        } catch (IOException e) {//            e.printStackTrace();//        }//    }////    private String getContentType(ContentTypeVO vo) {//        if (ContentTypeVO.X_WWW_FORM_URLENCODED.equals(vo.getRadio())) {//            return MediaType.APPLICATION_FORM_URLENCODED_VALUE;//        } else {//            return vo.getType();//        }//    }////    @Override//    @Transactional(rollbackFor = Exception.class)//    public Long debugAndSave(FastDebugConfigCreateInput input) {//        // 保存配置//        Long id = saveConfig(input);//        OperationLogContextHolder.addVars(Vars.FAST_DEBUG_CONFIG_ID, String.valueOf(id));//        // 开始调试//        return debug(id);//    }////    @Override//    public Long debugAndUpdate(FastDebugConfigUpdateInput input) {//        updateConfig(input);//        return debug(input.getId());//    }////    @Override//    public FastDebugLocateCallstackOutput locateCallstackNode(Long nodeId) {//        TraceNodeInfoResult result = traceNodeDao.getById(nodeId);//        if(result == null) {//            throw new TroWebException(ExceptionCode.FAST_DEBUG_CALLSTACK_LOCATE_ERROR, "未找到节点");//        }//        String traceId = result.getTraceId();//        // appName + '|' + agentId + '|' +  rpcId  + '|' + logType//        String locateNode = result.getAppName() + "|" + result.getAgentId() + "|" + result.getRpcId() + "|"//            + result.getLogType();////        List<FastDebugCallStackVO> vos = getCallStack(traceId, -1);//        List<Integer> locateNodeList = Lists.newArrayList();//        BiMap<Integer, Integer> node = HashBiMap.create();//        // 根节点定位//        String stack = vos.get(0).getAppName() + "|" + vos.get(0).getAgentId() + "|" + vos.get(0).getRpcId() + "|" +//            vos.get(0).getLogType();//        if (stack.equals(locateNode)) {//            List<FastDebugCallStackVO> rootResult = Lists.newArrayList();//            coverResult(vos, 0, rootResult);//            locateNodeList.add(0);//            return new FastDebugLocateCallstackOutput(0, rootResult, locateNodeList);//        }//        // 定位//        locate(vos.get(0).getNextNodes(), locateNode, 0, node, locateNodeList);//        // 从第二层开始丢弃无用的//        Collections.reverse(locateNodeList);//        for (int i = 0; i < locateNodeList.size() - 1; i++) {//            discard(vos.get(0).getNextNodes(), i, locateNodeList.get(i));//        }////        return new FastDebugLocateCallstackOutput(locateNodeList.get(locateNodeList.size() - 1), vos,getExpandedRow(locateNodeList));//    }////    private List<Integer> getExpandedRow(List<Integer> locateNodeList) {//        List<Integer> expandedRow = Lists.newArrayList();//        expandedRow.add(0);//        expandedRow.addAll(locateNodeList.subList(0,locateNodeList.size() -1));//        return expandedRow;//    }////    private void discard(List<FastDebugCallStackVO> vos, int level, Integer id) {//        for (FastDebugCallStackVO stackVO : vos) {//            if (level + 2 == stackVO.getLevel() && !stackVO.getId().equals(id)) {//                if (stackVO.getNextNodes() != null && stackVO.getNextNodes().size() > 0) {//                    stackVO.setNextNodes(Lists.newArrayList());//                }//            }//        }//    }////    /**//     * 定位//     *///    private void locate(List<FastDebugCallStackVO> vos, String locateNode, Integer parentId,//        BiMap<Integer, Integer> node, List<Integer> locateNodeList) {//        for (FastDebugCallStackVO stackVO : vos) {//            node.forcePut(parentId, stackVO.getId());//            String stack = stackVO.getAppName() + "|" + stackVO.getAgentId() + "|" + stackVO.getRpcId() + "|" +//                stackVO.getLogType();//            if (stack.equals(locateNode)) {//                // 向上递归//                setLocateNode(locateNodeList, node, stackVO.getId());//                return;//            }//            if (stackVO.getNextNodes() == null || stackVO.getNextNodes().size() == 0) {//                continue;//            }//            locate(stackVO.getNextNodes(), locateNode, stackVO.getId(), node, locateNodeList);//        }//    }////    private void setLocateNode(List<Integer> locateNodeList, BiMap<Integer, Integer> node, Integer id) {//        // 层级获取//        while (node.containsValue(id)) {//            locateNodeList.add(id);//            id = node.inverse().get(id);//        }//    }////    @Override//    public List<FastDebugCallStackVO> getCallStack(String traceId, Integer id) {//        RpcStack rpcStack = Optional.ofNullable(traceClient.getTraceDetailById(traceId)).orElseGet(RpcStack::new);//        String path = getFilePath(callStackPath, traceId, RestContext.getCustomerId());//        if (new File(path).exists()) {//            try {//                String stack = FileManagerHelper.readFileToString(new File(path), "UTF-8");//                // 比对大小//                String newStack = JsonHelper.bean2Json(rpcStack);//                if (newStack.length() >= stack.length()) {//                    FileManagerHelper.deleteFilesByPath(path);//                    FileManagerHelper.createFileByPathAndString(path, JsonHelper.bean2Json(rpcStack));//                } else {//                    rpcStack = JsonHelper.json2Bean(stack, RpcStack.class);//                }//            } catch (Exception e) {//                throw new TroWebException(ExceptionCode.FAST_SEARCH_ERROR, e.getLocalizedMessage());//            }//        } else {//            // 没有文件，取调用栈//            FileManagerHelper.createFileByPathAndString(path, JsonHelper.bean2Json(rpcStack));//            log.error("没有文件{}", traceId);//        }//        Optional.ofNullable(rpcStack)//            .orElseThrow(() -> new TroWebException(ExceptionCode.FAST_SEARCH_ERROR, "未查到调用栈信息"));//        List<FastDebugStackInfoOutPut> outPuts = fastDebugAgentUploadService.getErrorStackInfoList(traceId);//        // 全部以大数据的为准//        List<String> errorStack = outPuts.stream().map(FastDebugStackInfoOutPut::toString).collect(Collectors.toList());//        List<TraceNodeInfoResult> traceNodes = traceNodeDao.getUnknownNodes(traceId, RestContext.getCustomerId());//        List<String> unknownNodes = traceNodes.stream().map(TraceNodeInfoResult::toString).collect(Collectors.toList());//        return getFastDebugCallStackVOS(id, rpcStack, errorStack, unknownNodes);//    }////    public List<FastDebugCallStackVO> getFastDebugCallStackVOS(Integer id, RpcStack rpcStack, List<String> errorStack,//        List<String> unknownNodes) {//        List<FastDebugCallStackVO> vos = Lists.newArrayList();//        BiMap<Integer, Integer> node = HashBiMap.create();//        AtomicInteger integer = new AtomicInteger(0);//        List<FastDebugCallStackVO> voList = coverEntriesList(Lists.newArrayList(), rpcStack.getRpcEntries(), vos, node,//            -1, integer, errorStack, unknownNodes);//        if (id > -1) {//            List<FastDebugCallStackVO> result = Lists.newArrayList();//            coverResult(voList, id, result);//            return result;//        }//        return voList;//    }////    private void coverResult(List<FastDebugCallStackVO> voList, Integer id, List<FastDebugCallStackVO> result) {//        if (CollectionUtils.isEmpty(voList)) {//            return;//        }//        if (id == 0) {//            if (voList.get(0).getNextNodes() != null) {//                voList.get(0).getNextNodes().forEach(dto -> {//                    dto.setNextNodes(//                        dto.getNextNodes() != null && dto.getNextNodes().size() > 0 ? Lists.newArrayList() : null);//                });//            }//            result.addAll(voList);//            return;//        }//        for (FastDebugCallStackVO vo : voList) {//            if (vo.getId().equals(id)) {//                if (vo.getNextNodes() != null) {//                    result.addAll(vo.getNextNodes());//                }//            }//            coverResult(vo.getNextNodes(), id, result);//        }//    }////    private List<FastDebugCallStackVO> coverEntriesList(List<String> convertedEntriesList, List<RpcEntry> rpcEntries,//        List<FastDebugCallStackVO> vos, BiMap<Integer, Integer> node, Integer id, AtomicInteger integer,//        List<String> errorStack, List<String> unknownNodes) {//        if (CollectionUtils.isEmpty(rpcEntries)) {//            return null;//        }//        List<FastDebugCallStackVO> outputs = rpcEntries.stream().map(rpcEntry -> {//            String convertedEntriesKey = rpcEntry.getAppName() + "|" + rpcEntry.getServiceName() + "|" +//                rpcEntry.getMethodName() + "|" + rpcEntry.getRpcType() + "|" + rpcEntry.getMiddlewareName()//                + "|" + rpcEntry.getRpcId();////            if (convertedEntriesList.contains(convertedEntriesKey)) {//                return null;//            }//            convertedEntriesList.add(convertedEntriesKey);//            FastDebugCallStackVO output = new FastDebugCallStackVO();//            output.setId(integer.getAndIncrement());//            node.forcePut(id, output.getId());//            output.setClusterTest(rpcEntry.isClusterTest());//            output.setTraceId(rpcEntry.getTraceId());//            output.setRpcId(rpcEntry.getRpcId());//            output.setLevel(rpcEntry.getLevel());//            // 新增返回码//            output.setResultCode(rpcEntry.getResultCode());//            output.setAppName(rpcEntry.getAppName());//            // 根据log//            output.setAgentId(rpcEntry.getLogType() == Pradar.LOG_TYPE_RPC_CLIENT ?//                rpcEntry.getClientAgentId() : rpcEntry.getServerAgentId());//            output.setLogType(//                rpcEntry.getLogType() == Pradar.LOG_TYPE_RPC_CLIENT ? TraceNodeConstant.LOG_TYPE_RPC_CLIENT//                    : TraceNodeConstant.LOG_TYPE_RPC_SERVER);//            output.setInterfaceName(rpcEntry.getMethodName());//            List<String> appAndMiddleware = Lists.newArrayList();//            appAndMiddleware.add(rpcEntry.getAppName());//            appAndMiddleware.add(rpcEntry.getMiddlewareName());//            output.setAppAndMiddleware(appAndMiddleware);//            output.setServiceName(rpcEntry.getServiceName());//            // 优先判断agent，没有则判断调用栈。0317修改为全部以大数据数据为准//            // appName + '|' + agentId + '|' +  rpcId  + '|' + type//            String stack = output.getAppName() + "|" + output.getAgentId() + "|" + output.getRpcId() + "|" +//                output.getLogType();//            //if (errorStack.contains(stack)) {//            //    output.setSuccess(false);//            //} else {//            //    output.setSuccess(ResultCode.isOk(rpcEntry.getResultCode()));//            //}//            output.setSuccess(ResultCode.isOk(rpcEntry.getResultCode()));//            // 是否未知节点//            if (unknownNodes.contains(stack)) {//                output.setIsUpperUnknownNode(true);//            } else {//                output.setIsUpperUnknownNode(false);//            }//            output.setNodeSuccess(true);//            if (!output.getSuccess()) {//                // 向上递归//                setParentNode(vos, node, output.getId());//            }//            vos.add(output);//            output.setNextNodes(//                coverEntriesList(convertedEntriesList, rpcEntry.getRpcEntries(), vos, node, output.getId(), integer,//                    errorStack, unknownNodes));//            //rpcEntry = null;//            return output;//        }).filter(Objects::nonNull).collect(Collectors.toList());//        return outputs;//    }////    private void setParentNode(List<FastDebugCallStackVO> vos, BiMap<Integer, Integer> node, Integer id) {//        // 层级获取//        List<Integer> nodes = Lists.newArrayList();//        while (node.containsValue(id)) {//            id = node.inverse().get(id);//            nodes.add(id);//        }//        if (vos != null && vos.size() > 0) {//            vos.forEach(vo -> {//                if (nodes.contains(vo.getId())) {//                    vo.setNodeSuccess(false);//                }//            });//        }//    }////    @Override//    public List<FastDebugCallStackExceptionVO> getCallStackException(Long resultId, String traceId, Integer type) {//        CallStackExceptionEnum exceptionEnum = CallStackExceptionEnum.getExceptionEnumByType(type);//        if (exceptionEnum == null) {//            throw new TroWebException(ExceptionCode.FAST_DEBUG_GET_CALLSTACK_EXCEPTION_ERROR, "未知异常");//        }//        List<FastDebugCallStackExceptionVO> exceptionVOS = Lists.newArrayList();//        FastDebugResult debugResult = fastDebugDao.selectDebugResultById(resultId);//        if(debugResult == null) {//            throw new TroWebException(ExceptionCode.FAST_SEARCH_ERROR, resultId + "不存在");//        }//        List<TraceNodeInfoResult> infoResults = traceNodeDao.getNodeList(traceId, debugResult.getCustomerId());//        switch (exceptionEnum) {//            case NODE_OTHER_EXCEPTION://                // 流量标识异常//                List<TraceNodeInfoResult> exceptions = infoResults.stream().filter(result -> !result.getClusterTest()).collect(//                    Collectors.toList());//                exceptionVOS.add(new FastDebugCallStackExceptionVO(CallStackExceptionEnum.NODE_SIGN_EXCEPTION,//                    exceptions.stream().map(node -> {//                        FastDebugNodeExceptionVO exceptionVO = new FastDebugNodeExceptionVO();//                        BeanUtils.copyProperties(node, exceptionVO);//                        exceptionVO.setType(CallStackExceptionEnum.NODE_SIGN_EXCEPTION.getType());//                        return exceptionVO;//                    }).collect(Collectors.toList())));//                // 缺少节点//                if (StringUtils.isNotBlank(debugResult.getErrorMessage())) {//                    Map<String, String> map = JsonHelper.string2Obj(debugResult.getErrorMessage(),//                        new TypeReference<Map<String, String>>() {});//                    String callStackMessage = map.get(FastDebugErrorEnum.CALLSTACK_LOST_NODE_DETAIL.getType());//                    if (StringUtils.isNotBlank(callStackMessage)) {//                        Map<String, List<TraceNodeVO>> callStack = JsonHelper.string2Obj(callStackMessage,//                            new TypeReference<Map<String, List<TraceNodeVO>>>() {});//                        List<FastDebugNodeExceptionVO> nodeExceptionVOS = Lists.newArrayList();//                        for (Map.Entry<String, List<TraceNodeVO>> entry : callStack.entrySet()) {//                            nodeExceptionVOS.addAll(entry.getValue().stream().map(node -> {//                                FastDebugNodeExceptionVO exceptionVO = new FastDebugNodeExceptionVO();//                                BeanUtils.copyProperties(node, exceptionVO);//                                exceptionVO.setSuccess("success".equals(entry.getKey()));//                                exceptionVO.setType(CallStackExceptionEnum.NODE_LOST.getType());//                                return exceptionVO;//                            }).collect(Collectors.toList()));//                        }//                        exceptionVOS.add(new FastDebugCallStackExceptionVO(CallStackExceptionEnum.NODE_LOST,//                            nodeExceptionVOS));//                    }//                }//                break;//            case NODE_UNKNOWN://                // 未知节点//                List<TraceNodeInfoResult> results = traceNodeDao.getUnknownNodes(traceId, RestContext.getCustomerId());//                exceptionVOS.add(new FastDebugCallStackExceptionVO(exceptionEnum, results.stream().map(result -> {//                    FastDebugNodeExceptionVO exceptionVO = new FastDebugNodeExceptionVO();//                    BeanUtils.copyProperties(result, exceptionVO);//                    exceptionVO.setType(exceptionEnum.getType());//                    return exceptionVO;//                }).collect(Collectors.toList())));//                break;//            case NODE_EXCEPTION://                // 异常节点//                exceptionVOS.add(new FastDebugCallStackExceptionVO(exceptionEnum,infoResults.stream()//                    .filter(result -> {//                        //String stack = result.getAppName() + "|" + result.getAgentId() + "|" + result.getRpcId() + "|" +//                        //    result.getLogType();//                        // 异常节点//                        //return errorStack.contains(stack) || !ResultCode.isOk(result.getResultCode());//                        // 根据大数据判断//                        return  !ResultCode.isOk(result.getResultCode());//                    }).map(result -> {//                        FastDebugNodeExceptionVO exceptionVO = new FastDebugNodeExceptionVO();//                        BeanUtils.copyProperties(result, exceptionVO);//                        exceptionVO.setType(exceptionEnum.getType());//                        return exceptionVO;//                    }).collect(Collectors.toList())));//                break;//            default: {};//        }////        return exceptionVOS;//    }////    @Override//    public FastDebugCallStackDetailOutput getCallStackDetail(FastDebugCallStackDetailSearchInput input) {//        // 先从大数据拿数据//        TraceNodeInfoResult result = traceNodeDao.getNode(input.getTraceId(), input.getRpcId(),//            RestContext.getCustomerId(), input.getLogType(), input.getAgentId(), input.getAppName());//        FastDebugCallStackDetailOutput output = new FastDebugCallStackDetailOutput();//        String appName = "";//        if (CallStackExceptionEnum.NODE_LOST.getType().equals(input.getType())) {//            // 丢失节点，从agent上报数据中找//            result = null;//        }//        if (result == null) {//            FastDebugStackInfoQueryParam param = new FastDebugStackInfoQueryParam();//            if (StringUtils.isNotBlank(input.getTraceId())) {//                param.setTraceId(input.getTraceId());//                param.setRpcId(input.getRpcId());//                param.setType(input.getLogType());//                param.setAgentId(input.getAgentId());//                param.setAppName(input.getAppName());//                List<FastDebugStackInfoResult> results = fastDebugStackInfoDao.selectByExample(param);//                output.setTraceId(input.getTraceId());//                output.setRpcId(input.getRpcId());//                if (results != null && results.size() > 0) {//                    FastDebugStackInfoResult infoResult = results.get(0);//                    BeanUtils.copyProperties(infoResult, output);//                    output.setSuccess(!infoResult.getLevel().equals(LogLevelEnum.ERROR.getName()));//                    // 根据应用查看//                    appName = infoResult.getAppName();//                }//            }//        } else {//            BeanUtils.copyProperties(result, output);//            appName = result.getAppName();//        }//        if (StringUtils.isNotBlank(appName)) {//            List<FastDebugExceptionVO> exceptionResults = fastDebugDao.getException(input.getTraceId(),//                input.getRpcId(), appName, "");//            if (exceptionResults.size() > 0) {//                output.setException(exceptionResults.stream().distinct().collect(Collectors.toList()));//            }//        }//        return output;//    }////    @Override//    public List<FastDebugResultLeakSqlOutput> getLeakageCheckDataResult(Long resultId) {//        FastDebugResult result = fastDebugDao.selectDebugResultById(resultId);//        List<FastDebugResultLeakSqlOutput> outputs = Lists.newArrayList();//        if (StringUtils.isNotBlank(result.getLeakageCheckData())) {//            LeakVerifyTaskResultResponse response = JsonHelper.json2Bean(result.getLeakageCheckData(),//                LeakVerifyTaskResultResponse.class);//            if (response.getDsResultResponseList() != null && response.getDsResultResponseList().size() > 0) {//                response.getDsResultResponseList().forEach(dsResult -> {//                    FastDebugResultLeakSqlOutput sqlOutput = new FastDebugResultLeakSqlOutput();//                    sqlOutput.setName(dsResult.getDatasourceName());//                    sqlOutput.setJdbcUrl(dsResult.getJdbcUrl());//                    sqlOutput.setStatusResponse(dsResult.getStatusResponse());//                    if (dsResult.getDetailResponseList() != null && dsResult.getDetailResponseList().size() > 0) {//                        List<LeakSqlResultVO> vos = dsResult.getDetailResponseList().stream().map(//                            detailResponse -> {//                                LeakSqlResultVO resultVO = new LeakSqlResultVO();//                                BeanUtils.copyProperties(detailResponse, resultVO);//                                // 序号加1//                                resultVO.setOrder(resultVO.getOrder() + 1);//                                return resultVO;//                            }).collect(Collectors.toList());//                        sqlOutput.setVos(vos);//                    }//                    outputs.add(sqlOutput);//                });//            }//        }//        return outputs;//    }////    @Override//    public void importExcel(String path) {//        Map<String, List<ExcelExceptionVO>> map = ExcelUtil.readExcel(path, ExcelExceptionVO.class);//        List<ExceptionParam> params = Lists.newArrayList();//        List<ExceptionResult> results = exceptionDao.getList();//        Map<String, Long> resultMap = results.stream()//            .collect(Collectors.toMap(ExceptionResult::getCode, ExceptionResult::getId));//        map.keySet().forEach(key -> {//            params.addAll(map.get(key).stream().filter(v ->//                StringUtils.isNotBlank(v.getCode()) &&//                    StringUtils.isNotBlank(v.getDesc()) &&//                    StringUtils.isNotBlank(v.getSuggestion())//            ).map(vo -> {//                ExceptionParam param = new ExceptionParam();//                param.setCode(vo.getCode().trim());//                param.setId(Optional.ofNullable(resultMap.get(param.getCode())).orElse(null));//                param.setType(key.trim());//                param.setDescription(vo.getDesc().trim());//                param.setSuggestion(vo.getSuggestion().trim());//                param.setCount(0L);//                param.setAgentCode(//                    StringUtils.isNotBlank(vo.getAgentCode()) ? vo.getAgentCode().trim() : vo.getCode().trim());//                return param;//            }).collect(Collectors.toList()));//        });////        params.forEach(param -> exceptionDao.insert(param));////    }////    @Contract(threading = ThreadingBehavior.IMMUTABLE)//    public static class MyRedirectStrategy extends DefaultRedirectStrategy {////        public static final MyRedirectStrategy INSTANCE = new MyRedirectStrategy();////        /**//         * Redirectable methods.//         *///        private static final String[] REDIRECT_METHODS = new String[] {//            HttpGet.METHOD_NAME,//            HttpPost.METHOD_NAME,//            HttpPut.METHOD_NAME,//            HttpDelete.METHOD_NAME,//        };////        @Override//        protected boolean isRedirectable(final String method) {//            for (final String m : REDIRECT_METHODS) {//                if (m.equalsIgnoreCase(method)) {//                    return true;//                }//            }//            return false;//        }//    }////    public class NoRedirectClientHttpRequestFactory extends SimpleClientHttpRequestFactory {//        @Override//        protected void prepareConnection(HttpURLConnection connection, String httpMethod) throws IOException {//            super.prepareConnection(connection, httpMethod);//            connection.setInstanceFollowRedirects(false);//        }//    }////    public class MyRestErrorHandler implements ResponseErrorHandler {////        /**//         * 判断返回结果response是否是异常结果//         * 主要是去检查response 的HTTP Status//         * 仿造DefaultResponseErrorHandler实现即可//         *///        @Override//        public boolean hasError(ClientHttpResponse response) throws IOException {//            int rawStatusCode = response.getRawStatusCode();//            HttpStatus statusCode = HttpStatus.resolve(rawStatusCode);//            return (statusCode != null ? statusCode.isError() : hasError(rawStatusCode));//        }////        protected boolean hasError(int unknownStatusCode) {//            HttpStatus.Series series = HttpStatus.Series.resolve(unknownStatusCode);//            return (series == HttpStatus.Series.CLIENT_ERROR || series == HttpStatus.Series.SERVER_ERROR);//        }////        @Override//        public void handleError(ClientHttpResponse response) throws IOException {//            // 里面可以实现你自己遇到了Error进行合理的处理//        }//    }////}